home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2005 October / PCWOCT05.iso / Software / FromTheMag / XAMPP 1.4.14 / xampp-win32-1.4.14-installer.exe / xampp / php / pear / File / Passwd / Cvs.php < prev    next >
PHP Script  |  2004-10-01  |  9KB  |  295 lines
  1. <?php
  2. // +----------------------------------------------------------------------+
  3. // | PEAR :: File :: Passwd :: Cvs                                        |
  4. // +----------------------------------------------------------------------+
  5. // | This source file is subject to version 3.0 of the PHP license,       |
  6. // | that is available at http://www.php.net/license/3_0.txt              |
  7. // | If you did not receive a copy of the PHP license and are unable      |
  8. // | to obtain it through the world-wide-web, please send a note to       |
  9. // | license@php.net so we can mail you a copy immediately.               |
  10. // +----------------------------------------------------------------------+
  11. // | Copyright (c) 2003-2004 Michael Wallner <mike@iworks.at>             |
  12. // +----------------------------------------------------------------------+
  13. //
  14. // $Id: Cvs.php,v 1.12 2004/06/07 19:19:47 mike Exp $
  15.  
  16. /**
  17. * Manipulate CVS pserver passwd files.
  18. * 
  19. * @author   Michael Wallner <mike@php.net>
  20. * @package  File_Passwd
  21. */
  22.  
  23. /**
  24. * Requires File::Passwd::Common
  25. */
  26. require_once 'File/Passwd/Common.php';
  27.  
  28. /**
  29. * Manipulate CVS pserver passwd files.
  30. * 
  31. * <kbd><u>
  32. *   A line of a CVS pserver passwd file consists of 2 to 3 colums:
  33. * </u></kbd>
  34. * <pre>
  35. *   user1:1HCoDDWxK9tbM:sys_user1
  36. *   user2:0O0DYYdzjCVxs
  37. *   user3:MIW9UUoifhqRo:sys_user2
  38. * </pre>
  39. * 
  40. * If the third column is specified, the CVS user named in the first column is 
  41. * mapped to the corresponding system user named in the third column.
  42. * That doesn't really affect us - just for your interest :)
  43. * 
  44. * <kbd><u>Output of listUser()</u></kbd>
  45. * <pre>
  46. *      array
  47. *       + user =>  array
  48. *                   + passwd => crypted_passwd
  49. *                   + system => system_user
  50. *       + user =>  array
  51. *                   + passwd => crypted_passwd
  52. *                   + system => system_user
  53. * </pre>
  54. * 
  55. * @author   Michael Wallner <mike@php.net>
  56. * @package  File_Passwd
  57. * @version  $Revision: 1.12 $
  58. * @access   public
  59. */
  60. class File_Passwd_Cvs extends File_Passwd_Common
  61. {
  62.     /**
  63.     * Constructor
  64.     *
  65.     * @access public
  66.     */
  67.     function File_Passwd_Cvs($file = 'passwd')
  68.     {
  69.         parent::__construct($file);
  70.     }
  71.     
  72.     /**
  73.     * Fast authentication of a certain user
  74.     * 
  75.     * Returns a PEAR_Error if:
  76.     *   o file doesn't exist
  77.     *   o file couldn't be opened in read mode
  78.     *   o file couldn't be locked exclusively
  79.     *   o file couldn't be unlocked (only if auth fails)
  80.     *   o file couldn't be closed (only if auth fails)
  81.     *
  82.     * @static   call this method statically for a reasonable fast authentication
  83.     * @access   public
  84.     * @return   mixed   true if authenticated, false if not or PEAR_Error
  85.     * @param    string  $file   path to passwd file
  86.     * @param    string  $user   user to authenticate
  87.     * @param    string  $pass   plaintext password
  88.     */
  89.     function staticAuth($file, $user, $pass)
  90.     {
  91.         $line = File_Passwd_Common::_auth($file, $user);
  92.         if (!$line || PEAR::isError($line)) {
  93.             return $line;
  94.         }
  95.         @list(,$real)   = explode(':', $line);
  96.         return (File_Passwd_Cvs::generatePassword($pass, $real) === $real);
  97.     }
  98.     
  99.     /**
  100.     * Apply changes and rewrite CVS passwd file
  101.     *
  102.     * Returns a PEAR_Error if:
  103.     *   o directory in which the file should reside couldn't be created
  104.     *   o file couldn't be opened in write mode
  105.     *   o file couldn't be locked exclusively
  106.     *   o file couldn't be unlocked
  107.     *   o file couldn't be closed
  108.     * 
  109.     * @throws PEAR_Error
  110.     * @access public
  111.     * @return mixed true on success or PEAR_Error
  112.     */
  113.     function save()
  114.     {
  115.         $content = '';
  116.         foreach ($this->_users as $user => $v){
  117.             $content .= $user . ':' . $v['passwd'];
  118.             if (isset($v['system']) && !empty($v['system'])) {
  119.                 $content .= ':' . $v['system'];
  120.             }
  121.             $content .= "\n";
  122.         }
  123.         return $this->_save($content);
  124.     }
  125.     
  126.     /** 
  127.     * Parse the CVS passwd file
  128.     *
  129.     * Returns a PEAR_Error if passwd file has invalid format.
  130.     * 
  131.     * @throws PEAR_Error
  132.     * @access public
  133.     * @return mixed true on success or PEAR_Error
  134.     */
  135.     function parse()
  136.     {
  137.         $this->_users = array();
  138.         foreach ($this->_contents as $line) {
  139.             $user = explode(':', $line);
  140.             if (count($user) < 2) {
  141.                 return PEAR::raiseError(
  142.                     FILE_PASSWD_E_INVALID_FORMAT_STR,
  143.                     FILE_PASSWD_E_INVALID_FORMAT
  144.                 );
  145.             }
  146.             @list($user, $pass, $system) = $user;
  147.             $this->_users[$user]['passwd'] = $pass;
  148.             if (!empty($system)) {
  149.                 $this->_users[$user]['system'] = $system;
  150.             }
  151.         }
  152.         $this->_contents = array();
  153.         return true;
  154.     }
  155.  
  156.     /**
  157.     * Add an user
  158.     *
  159.     * The username must start with an alphabetical character and must NOT
  160.     * contain any other characters than alphanumerics, the underline and dash.
  161.     * 
  162.     * Returns a PEAR_Error if:
  163.     *   o user already exists
  164.     *   o user or system_user contains illegal characters
  165.     * 
  166.     * @throws PEAR_Error
  167.     * @access public
  168.     * @return mixed true on success or PEAR_Error
  169.     * @param  string    $user           the name of the user to add
  170.     * @param  string    $pass           the password of the user tot add
  171.     * @param  string    $system_user    the systemuser this user maps to
  172.     */
  173.     function addUser($user, $pass, $system_user = '')
  174.     {
  175.         if ($this->userExists($user)) {
  176.             return PEAR::raiseError(
  177.                 sprintf(FILE_PASSWD_E_EXISTS_ALREADY_STR, 'User ', $user),
  178.                 FILE_PASSWD_E_EXISTS_ALREADY
  179.             );
  180.         }
  181.         if (!preg_match($this->_pcre, $user)) {
  182.             return PEAR::raiseError(
  183.                 sprintf(FILE_PASSWD_E_INVALID_CHARS_STR, 'User ', $user),
  184.                 FILE_PASSWD_E_INVALID_CHARS
  185.             );
  186.         }
  187.         @setType($system_user, 'string');
  188.         if (!empty($system_user) && !preg_match($this->_pcre, $system_user)) {
  189.             return PEAR::raiseError(
  190.                 sprintf(
  191.                     FILE_PASSWD_E_INVALID_CHARS_STR, 
  192.                     'System user ', 
  193.                     $system_user
  194.                 ),
  195.                 FILE_PASSWD_E_INVALID_CHARS
  196.             );
  197.         }
  198.         $this->_users[$user]['passwd'] = $this->generatePassword($pass);
  199.         $this->_users[$user]['system'] = $system_user;
  200.         return true;
  201.     }
  202.     
  203.     /**
  204.     * Verify the password of a certain user
  205.     *
  206.     * Returns a PEAR_Error if the user doesn't exist.
  207.     * 
  208.     * @throws PEAR_Error
  209.     * @access public
  210.     * @return mixed true if passwords equal, false ifthe don't or PEAR_Error
  211.     * @param  string    $user   user whose password should be verified
  212.     * @param  string    $pass   the plaintext password that should be verified
  213.     */
  214.     function verifyPasswd($user, $pass)
  215.     {
  216.         if (!$this->userExists($user)) {
  217.             return PEAR::raiseError(
  218.                 sprintf(FILE_PASSWD_E_EXISTS_NOT_STR, 'User ', $user),
  219.                 FILE_PASSWD_E_EXISTS_NOT
  220.             );
  221.         }
  222.         $real = $this->_users[$user]['passwd'];
  223.         return ($real === $this->generatePassword($pass, $real));
  224.     }
  225.     
  226.     /**
  227.     * Change the password of a certain user
  228.     *
  229.     * Returns a PEAR_Error if user doesn't exist.
  230.     * 
  231.     * @throws PEAR_Error
  232.     * @access public
  233.     * @return mixed true on success or PEAR_Error
  234.     */
  235.     function changePasswd($user, $pass)
  236.     {
  237.         if (!$this->userExists($user)) {
  238.             return PEAR::raiseError(
  239.                 sprintf(FILE_PASSWD_E_EXISTS_NOT_STR, 'User ', $user),
  240.                 FILE_PASSWD_E_EXISTS_NOT
  241.             );
  242.         }
  243.         $this->_users[$user]['passwd'] = $this->generatePassword($pass);
  244.         return true;
  245.     }
  246.     
  247.     /**
  248.     * Change the corresponding system user of a certain cvs user
  249.     *
  250.     * Returns a PEAR_Error if:
  251.     *   o user doesn't exist
  252.     *   o system user contains illegal characters
  253.     * 
  254.     * @throws PEAR_Error
  255.     * @access public
  256.     * @return mixed true on success or PEAR_Error
  257.     */
  258.     function changeSysUser($user, $system)
  259.     {
  260.         if (!$this->userExists($user)) {
  261.             return PEAR::raiseError(
  262.                 sprintf(FILE_PASSWD_E_EXISTS_NOT_STR, 'User ', $user),
  263.                 FILE_PASSWD_E_EXISTS_NOT
  264.             );
  265.         }
  266.         if (!preg_match($this->_pcre, $system)) {
  267.             return PEAR::raiseError(
  268.                 sprintf(
  269.                     FILE_PASSWD_E_INVALID_CHARS_STR, 
  270.                     'System user ', 
  271.                     $system_user
  272.                 ),
  273.                 FILE_PASSWD_E_INVALID_CHARS
  274.             );
  275.         }
  276.         $this->_users[$user]['system'] = $system;
  277.         return true;
  278.     }
  279.     
  280.     /**
  281.     * Generate crypted password
  282.     *
  283.     * @static
  284.     * @access public
  285.     * @return string    the crypted password
  286.     * @param  string    $pass   new plaintext password
  287.     * @param  string    $salt   new crypted password from which to gain the salt
  288.     */
  289.     function generatePassword($pass, $salt = null)
  290.     {
  291.         return File_Passwd::crypt_des($pass, $salt);
  292.     }
  293.     
  294. }
  295. ?>